home *** CD-ROM | disk | FTP | other *** search
/ Shareware Grab Bag / Shareware Grab Bag.iso / 007 / jovept2.arc / MARKS.C < prev    next >
Text File  |  1985-05-30  |  4KB  |  217 lines
  1. /* marks.c */
  2.  
  3. /* JOVE/MSDOS. K. Mitchum 1/85 */
  4. /* Modifications for personal use only. */
  5. /* original code J. Payne LSRHS 5/83 */
  6. /* Ken Mitchum */
  7. /* University of Pittsburgh */
  8. /* Decision Systems Laboratory */
  9.  
  10.  
  11. /*
  12.    Jonathan Payne at Lincoln-Sudbury Regional High School 5-25-83
  13.   
  14.    jove_marks.c
  15.  
  16.    Creation of marks, and routines to adjust the marks after insertion
  17.    or deletion.  */
  18.  
  19. #include "jove.h"
  20.  
  21. MARK *
  22. DoMakeMark(buf, line, column)
  23. BUFFER    *buf;
  24. register LINE    *line;
  25. {
  26.     MARK    *newmark;
  27.     newmark = (MARK *) emalloc(sizeof (struct mark));
  28.  
  29.     MarkSet(newmark, line, column);
  30.     newmark->m_next = buf->b_marks;
  31.     buf->b_marks = newmark;
  32.     return newmark;
  33. }
  34.  
  35. MARK *
  36. MakeMark(line, col)
  37. LINE    *line;
  38. {
  39.     return DoMakeMark(curbuf, line, col);
  40. }
  41.  
  42. DelMark(m)
  43. MARK    *m;
  44. {
  45.     DoDelMark(curbuf, m);
  46. }
  47.  
  48. DoDelMark(b, m)
  49. BUFFER    *b;
  50. register MARK    *m;
  51. {
  52.     register MARK    *mp = b->b_marks;
  53.  
  54.     if (m == mp)
  55.         b->b_marks = m->m_next;
  56.     else {
  57.         while (mp != 0 && mp->m_next != m)
  58.             mp = mp->m_next;
  59.         if (mp == 0)
  60.             complain("Trying to delete unknown mark!");
  61.         mp->m_next = m->m_next;
  62.     }
  63.     free((char *) m);
  64. }
  65.  
  66. AllMarkSet(b, line, col)
  67. BUFFER    *b;
  68. register LINE    *line;
  69. {
  70.     register MARK    *mp;
  71.  
  72.     for (mp = b->b_marks; mp; mp = mp->m_next)
  73.         MarkSet(mp, line, col);
  74. }
  75.  
  76. MarkSet(m, line, column)
  77. MARK    *m;
  78. LINE    *line;
  79. {
  80.     m->m_line = line;
  81.     m->m_char = column;
  82. }
  83.  
  84. PopMark()
  85. {
  86.     int    pmark;
  87.  
  88.     if (curmark == 0)
  89.         return;
  90.     if (curbuf->b_markring[(curbuf->b_themark + 1) % NMARKS] == 0) {
  91.         pmark = curbuf->b_themark;
  92.         do {
  93.             if (--pmark < 0)
  94.                 pmark = NMARKS - 1;
  95.         } while (curbuf->b_markring[pmark] != 0);
  96.  
  97.         curbuf->b_markring[pmark] = MakeMark(curline, curchar);
  98.         ToMark(curmark);
  99.         DelMark(curmark);
  100.         curmark = 0;
  101.     } else
  102.         PtToMark();
  103.  
  104.     pmark = curbuf->b_themark - 1;
  105.     if (pmark < 0)
  106.         pmark = NMARKS - 1;
  107.     curbuf->b_themark = pmark;
  108. }
  109.  
  110. SetMark()
  111. {
  112.     if (exp_p)
  113.         PopMark();
  114.     else {
  115.         curbuf->b_themark = (curbuf->b_themark + 1) % NMARKS;
  116.         if (curmark == 0)
  117.             curmark = MakeMark(curline, curchar);
  118.         else
  119.             MarkSet(curmark, curline, curchar);
  120.         s_mess("Point pushed");
  121.     }
  122. }
  123.  
  124. /* Move point to mark */
  125.  
  126. ToMark(m)
  127. MARK    *m;
  128. {
  129.     if (m == 0)
  130.         return;
  131.     DotTo(m->m_line, m->m_char);
  132. }
  133.  
  134. MARK *
  135. CurMark()
  136. {
  137.     if (curmark == 0)
  138.         complain("No mark");
  139.     return curmark;
  140. }
  141.  
  142. PtToMark()
  143. {
  144.     LINE    *mline;
  145.     int    mchar;
  146.     MARK    *m = CurMark();
  147.  
  148.     mline = curline;
  149.     mchar = curchar;
  150.  
  151.     ToMark(m);
  152.     MarkSet(m, mline, mchar);
  153. }
  154.  
  155. /* Fix marks for after a deletion */
  156.  
  157. DFixMarks(line1, char1, line2, char2)
  158. register LINE    *line1,
  159.         *line2;
  160. {
  161.     register MARK    *m;
  162.     LINE    *lp = line1;
  163.  
  164.     if (curbuf->b_marks == 0)
  165.         return;
  166.     while (lp != line2->l_next) {
  167.         for (m = curbuf->b_marks; m; m = m->m_next)
  168.             if (m->m_line == lp)
  169.                 m->m_char |= (1 << 15);
  170.         lp = lp->l_next;
  171.     }
  172.     for (m = curbuf->b_marks; m; m = m->m_next) {
  173.         if ((m->m_char & (1 << 15)) == 0)
  174.             continue;    /* Not effected */
  175.         m->m_char &= ~(1 << 15);
  176.         if (m->m_line == line1 && m->m_char < char1)
  177.             continue;    /* This mark is not affected */
  178.         if (line1 == line2) {
  179.             if (m->m_char >= char1 && m->m_char <= char2)
  180.                 m->m_char = char1;
  181.             else if (m->m_char > char2)
  182.                 m->m_char -= (char2 - char1);
  183.             /* Same line move the mark backward */
  184.         } else if (m->m_line == line2) {
  185.             if (m->m_char > char2)
  186.                 m->m_char = char1 + (m->m_char - char2);
  187.             else
  188.                 m->m_char = char1;
  189.             m->m_line = line1;
  190.         } else {
  191.             m->m_char = char1;
  192.             m->m_line = line1;
  193.         }
  194.     }
  195. }
  196.  
  197. IFixMarks(line1, char1, line2, char2)
  198. register LINE    *line1,
  199.         *line2;
  200. {
  201.     register MARK    *m;
  202.  
  203.     for (m = curbuf->b_marks; m; m = m->m_next) {
  204.         if (m->m_line == line1) {
  205.             if (m->m_char > char1) {
  206.                 m->m_line = line2;
  207.                 if (line1 == line2)
  208.                     m->m_char += (char2 - char1);
  209.                 else
  210.                     m->m_char = char2 + (m->m_char - char1);
  211.             }
  212.         } 
  213.     }
  214. }
  215.  
  216. /* end */
  217.